// pages/function/function.js
Page({
  // 页面初始数据
  data: {
    isTeacher: false,  // 布尔值，标识用户是否为辅导员 (teacher角色)
    isStaff: false,    // 布尔值，标识用户是否为心理咨询师 (staff角色)
    userInfo: null,    // 对象，存储当前登录用户的信息
    isLogin: false     // 布尔值，标识用户是否已登录
  },

  // 页面加载时触发的生命周期函数，只会调用一次
  onLoad: function(options) {
    // 检查用户的登录状态
    this.checkLoginStatus();
  },

  // 页面显示/切入前台时触发的生命周期函数
  onShow: function() {
    // 每次页面显示时，都重新检查登录状态，确保信息是最新的
    this.checkLoginStatus();
    
    // 检查本地存储中是否有待处理的导航请求
    const pendingNavigation = wx.getStorageSync('pendingNavigation');
    // 如果存在待处理的导航请求，并且目标页面是 'testConfig'
    if (pendingNavigation && pendingNavigation.destination === 'testConfig') {
      // 获取当前时间戳
      const now = Date.now();
      // 获取导航请求中的时间戳，如果不存在则默认为0
      const timestamp = pendingNavigation.timestamp || 0;
      
      // 检查导航请求是否在30秒有效期内
      if (now - timestamp < 30000) {
        console.log('检测到待处理的导航请求，目标: testConfig');
        
        // 从本地存储中移除该导航标记，避免重复处理
        wx.removeStorageSync('pendingNavigation');
        
        // 延迟1秒执行导航，确保当前页面已完全加载完毕，提高稳定性
        setTimeout(() => {
          console.log('执行延迟导航');
          // 调用处理测试配置页面导航的函数
          this.handleTestConfigNavigation();
        }, 1000);
      } else {
        // 如果导航请求已过期，则打印日志并移除标记
        console.log('导航请求已过期，移除');
        wx.removeStorageSync('pendingNavigation');
      }
    }
  },

  // 检查用户登录状态的函数
  checkLoginStatus: function() {
    console.log('===== 检查登录状态 =====');
    // 从微信本地存储中同步获取 'userInfo' 数据
    const userInfo = wx.getStorageSync('userInfo');
    console.log('从本地存储获取的用户信息:', userInfo);
    
    // 判断userInfo是否存在，以此判断用户是否已登录
    if (userInfo) {
      console.log('用户已登录');
      console.log('用户角色:', userInfo.role);
      // 打印用户OpenID，兼容不同字段名 (_openid, openid, openId)
      console.log('用户OpenID:', userInfo.openid || userInfo._openid || userInfo.openId);
      
      // 根据userInfo中的role字段，设置isTeacher和isStaff状态
      // 'teacher' 或 'counselor' (兼容旧数据) 角色均视为辅导员
      const isTeacher = userInfo.role === 'teacher' || userInfo.role === 'counselor';
      // 'staff' 角色视为心理咨询师
      const isStaff = userInfo.role === 'staff';
      
      // 使用setData更新页面的数据，触发视图更新
      this.setData({
        userInfo: userInfo,    // 更新用户信息
        isLogin: true,         // 设置登录状态为true
        isTeacher: isTeacher,  // 更新辅导员状态
        isStaff: isStaff       // 更新心理咨询师状态
      });
      
      console.log('设置isTeacher(辅导员):', isTeacher);
      console.log('设置isStaff(心理咨询师):', isStaff);
    } else {
      // 如果userInfo不存在，表示用户未登录
      console.log('用户未登录');
      // 更新页面数据，将相关状态设置为false
      this.setData({
        isLogin: false,
        isTeacher: false,
        isStaff: false
      });
    }
    // 打印当前页面的data，方便调试
    console.log('当前页面状态:', this.data);
  },

  // "开始心理测试"按钮的点击事件处理函数
  startPsychologicalTest: function() {
    // 检查用户是否已登录
    if (!this.data.isLogin) {
      // 如果未登录，则导航到登录页面
      wx.navigateTo({
        url: '/pages/login/login', // 登录页面的路径
      });
      return; // 结束函数执行
    }
    // 如果已登录，则导航到心理测试首页
    wx.navigateTo({
      url: '/pages/psychological-test/index', // 心理测试页面的路径
    });
  },

  // "学生申请心理咨询"按钮的点击事件处理函数
  applyConsultation: function() {
    // 检查用户是否已登录
    if (!this.data.isLogin) {
      // 如果未登录，则导航到登录页面
      wx.navigateTo({
        url: '/pages/login/login',
      });
      return;
    }
    // 如果已登录，则导航到心理咨询申请页面
    wx.navigateTo({
      url: '/pages/application/application', // 申请页面的路径
    });
  },

  // "查看历史测评信息"按钮的点击事件处理函数
  viewHistory: function() {
    // 检查用户是否已登录
    if (!this.data.isLogin) {
      // 如果未登录，则导航到登录页面
      wx.navigateTo({
        url: '/pages/login/login',
      });
      return;
    }
    // 如果已登录，则导航到历史测评信息页面
    wx.navigateTo({
      url: '/pages/history/history', // 历史记录页面的路径
    });
  },

  // "心理咨询师查看待处理的心理咨询申请"按钮的点击事件处理函数
  viewPendingApplications: function() {
    console.log('===== 查看待处理的心理咨询申请 =====');
    // 检查用户是否已登录
    if (!this.data.isLogin) {
      console.log('用户未登录，跳转到登录页面');
      // 如果未登录，则导航到登录页面
      wx.navigateTo({
        url: '/pages/login/login',
      });
      return;
    }
    
    // 从本地存储获取当前用户信息
    const userInfo = wx.getStorageSync('userInfo');
    console.log('当前用户信息:', userInfo);
    console.log('用户角色:', userInfo.role);
    // 打印当前的isTeacher和isStaff状态，用于调试权限判断逻辑
    console.log('isTeacher状态:', this.data.isTeacher);
    console.log('isStaff状态:', this.data.isStaff);
    
    // 验证用户权限：此功能仅限心理咨询师 (staff角色) 使用
    if (!this.data.isStaff) {
      console.log('用户没有权限访问此功能');
      // 显示提示信息告知用户无权限
      wx.showToast({
        title: '您没有权限执行此操作',
        icon: 'none' // 不显示图标
      });
      return; // 结束函数执行
    }
    
    console.log('跳转到待审批申请页面');
    // 如果权限验证通过，则导航到待处理申请列表页面
    wx.navigateTo({
      url: '/pages/pending/pending', // 待处理申请页面的路径
    });
  },

  // "心理咨询结果处理"（工作人员专属功能）按钮的点击事件处理函数
  fillConsultationResult: function() {
    // 检查用户是否已登录
    if (!this.data.isLogin) {
      // 如果未登录，则导航到登录页面
      wx.navigateTo({
        url: '/pages/login/login',
      });
      return;
    }
    
    // 验证用户权限：此功能仅限心理咨询师 (staff角色) 使用
    if (!this.data.isStaff) {
      // 显示提示信息告知用户无权限
      wx.showToast({
        title: '您没有权限执行此操作',
        icon: 'none'
      });
      return;
    }
    
    // 导航到已批准申请列表页面，而不是直接到结果填写页
    // 通过filter=approved参数筛选已批准的申请
    wx.navigateTo({
      url: '/pages/pending/pending?filter=approved',
    });
  },
  
  // "心理咨询师查看咨询记录"按钮的点击事件处理函数
  viewConsultationRecords: function() {
    // 检查用户是否已登录
    if (!this.data.isLogin) {
      // 如果未登录，则导航到登录页面
      wx.navigateTo({
        url: '/pages/login/login',
      });
      return;
    }
    
    // 验证用户权限：此功能仅限心理咨询师 (staff角色) 使用
    if (!this.data.isStaff) {
      // 显示提示信息告知用户无权限
      wx.showToast({
        title: '您没有权限执行此操作',
        icon: 'none'
      });
      return;
    }
    
    // 如果权限验证通过，则导航到咨询记录查看页面
    wx.navigateTo({
      url: '/pages/consultation-records/index', // 咨询记录页面的路径
    });
  },
  
  // "心理咨询师查看定期回访"按钮的点击事件处理函数
  viewInterventionProgress: function() {
    // 检查用户是否已登录
    if (!this.data.isLogin) {
      // 如果未登录，则导航到登录页面
      wx.navigateTo({
        url: '/pages/login/login',
      });
      return;
    }
    
    // 验证用户权限：此功能仅限心理咨询师 (staff角色) 使用
    if (!this.data.isStaff) {
      // 显示提示信息告知用户无权限
      wx.showToast({
        title: '您没有权限执行此操作',
        icon: 'none'
      });
      return;
    }
    
    // 如果权限验证通过，则导航到定期回访/干预进展页面
    wx.navigateTo({
      url: '/pages/intervention-progress/index', // 定期回访页面的路径
    });
  },
  
  // "心理咨询师管理测评题目"按钮的点击事件处理函数
  manageTestQuestions: function() {
    // 检查用户是否已登录
    if (!this.data.isLogin) {
      // 如果未登录，则导航到登录页面
      wx.navigateTo({
        url: '/pages/login/login',
      });
      return;
    }
    
    // 验证用户权限：此功能仅限心理咨询师 (staff角色) 使用
    if (!this.data.isStaff) {
      // 显示提示信息告知用户无权限
      wx.showToast({
        title: '您没有权限执行此操作',
        icon: 'none'
      });
      return;
    }
    
    // 如果权限验证通过，则导航到测评题目管理页面
    wx.navigateTo({
      url: '/pages/staff/test-management/index', // 测评管理页面的路径
    });
  },
  
  // "数据修复：将所有用户的class字段迁移到classes数组"的函数 (通常为开发者调试使用)
  fixUserData: function() {
    // 获取数据库实例
    const db = wx.cloud.database();
    
    // 显示加载提示，告知用户正在进行数据修复
    wx.showLoading({
      title: '正在修复数据...',
    });
    
    // 查询 'users' 集合中所有 'class' 字段存在的文档
    db.collection('users').where({
      class: db.command.exists(true) // 使用db.command.exists判断字段是否存在
    }).get().then(res => {
      // 打印需要修复的用户数据数量
      console.log('需要修复的用户数据:', res.data.length);
      
      // 如果没有需要修复的数据，则隐藏加载提示并显示成功信息
      if (res.data.length === 0) {
        wx.hideLoading();
        wx.showToast({
          title: '没有需要修复的数据',
          icon: 'success'
        });
        return; // 结束函数执行
      }
      
      // 创建一个Promise数组，用于管理所有异步更新操作
      const promises = [];
      
      // 遍历查询到的每个用户数据
      res.data.forEach(user => {
        // 确保用户数据中存在 'class' 字段
        if (user.class) {
          let classIds = []; // 用于存储处理后的班级ID数组
          
          // 判断 'class' 字段是否为标准的ID格式 (24位或32位MongoDB ObjectId字符串长度)
          if (user.class.length === 24 || user.class.length === 32) {
            // 如果是ID格式，直接将其放入数组中
            classIds = [user.class];
          } 
          // 如果 'class' 字段不是ID格式 (可能是班级名称)
          else {
            // classIds保持为空数组，后续将通过查询 'classes' 集合来填充
            classIds = []; 
            
            // 将查询 'classes' 集合的Promise添加到promises数组中
            promises.push(
              db.collection('classes').where({
                name: user.class // 根据班级名称查询
              }).get().then(classRes => {
                // 如果查询到对应的班级信息
                if (classRes.data.length > 0) {
                  const classId = classRes.data[0]._id; // 获取班级的_id
                  
                  // 更新当前用户的文档，将 'classes' 字段设置为包含该班级ID的数组
                  return db.collection('users').doc(user._id).update({
                    data: {
                      classes: [classId],         // 新的classes字段
                      updateTime: db.serverDate() // 更新文档的修改时间
                    }
                  });
                }
                return Promise.resolve(); // 如果未找到对应班级，则不执行任何操作
              })
            );
          }
          
          // 如果classIds数组已经有内容 (即原 'class' 字段就是ID格式)
          if (classIds.length > 0) {
            // 直接更新当前用户的文档
            promises.push(
              db.collection('users').doc(user._id).update({
                data: {
                  classes: classIds,         // 将原ID存入数组
                  updateTime: db.serverDate() // 更新修改时间
                }
              })
            );
          }
        }
      });
      
      // 等待所有数据库更新操作完成
      return Promise.all(promises);
    }).then(() => {
      // 所有操作成功完成后，隐藏加载提示并显示成功信息
      wx.hideLoading();
      wx.showToast({
        title: '数据修复完成',
        icon: 'success'
      });
    }).catch(err => {
      // 如果任何一个操作失败，则捕获错误
      console.error('数据修复失败:', err);
      wx.hideLoading(); // 隐藏加载提示
      // 显示失败信息
      wx.showToast({
        title: '修复失败，请重试',
        icon: 'none'
      });
    });
  },
  
  // "初始化测试班级数据"的函数 (通常为开发者调试使用)
  initClassData: function() {
    // 获取数据库实例
    const db = wx.cloud.database();
    
    // 显示加载提示
    wx.showLoading({
      title: '初始化数据中...',
    });
    
    // 从本地存储获取当前用户信息，用于设置班级的counselorId
    const userInfo = wx.getStorageSync('userInfo');
    // 必须确保用户已登录并且其信息中包含_id字段
    if (!userInfo || !userInfo._id) {
      wx.hideLoading();
      wx.showToast({
        title: '请先登录',
        icon: 'none'
      });
      return; // 结束函数执行
    }
    
    // 第一步：检查名为 "111" 的班级是否存在
    db.collection('classes').where({
      name: "111"
    }).get().then(res => {
      console.log('查询班级"111"结果:', res.data);
      
      // 如果 "111" 班级不存在
      if (res.data.length === 0) {
        // 添加 "111" 班级到 'classes' 集合
        return db.collection('classes').add({
          data: {
            name: "111",                  // 班级名称
            counselorId: userInfo._id,    // 辅导员ID，设置为当前登录用户的ID
            department: "心理学系",       // 所属院系
            grade: "2023级",              // 年级
            createTime: db.serverDate(),  // 文档创建时间 (服务器时间)
            updateTime: db.serverDate()   // 文档更新时间 (服务器时间)
          }
        });
      } else {
        // 如果 "111" 班级已存在，获取其数据
        const classData = res.data[0];
        // 检查该班级是否已有关联的辅导员ID (counselorId)
        if (!classData.counselorId) {
          // 如果没有辅导员ID，则更新该班级文档，添加当前用户为辅导员
          return db.collection('classes').doc(classData._id).update({
            data: {
              counselorId: userInfo._id,    // 设置辅导员ID
              updateTime: db.serverDate()   // 更新修改时间
            }
          }).then(() => {
            // 更新成功后，重新获取该班级的最新数据并返回
            return db.collection('classes').doc(classData._id).get();
          }).then(updatedClass => {
            return updatedClass.data; // 返回班级的数据对象
          });
        }
        // 如果已有辅导员ID，则直接解析并返回现有班级数据
        return Promise.resolve(classData);
      }
    }).then(res => {
      // 此处 res 为 "111" 班级的数据或添加操作的结果
      console.log('添加/获取111班级结果:', res);
      let class111 = res; // 保存班级 "111" 的信息
      // 如果res是add操作的直接结果 (包含_id)，则构造一个标准班级对象
      if (res.hasOwnProperty('_id') && !res.name) { 
        class111 = { _id: res._id, name: "111", counselorId: userInfo._id, department: "心理学系", grade: "2023级" };
      }
      
      // 第二步：检查名为 "112" 的班级是否存在
      return db.collection('classes').where({
        name: "112"
      }).get().then(res112 => {
        let class112 = null; // 初始化班级 "112" 的信息变量
        // 如果 "112" 班级不存在
        if (res112.data.length === 0) {
          // 添加 "112" 班级
          return db.collection('classes').add({
            data: {
              name: "112",
              counselorId: userInfo._id,
              department: "心理学系",
              grade: "2023级",
              createTime: db.serverDate(),
              updateTime: db.serverDate()
            }
          }).then(newClass112Res => {
            // newClass112Res 是 add 操作的结果
            // 构造班级 "112" 的对象
            class112 = { _id: newClass112Res._id, name: "112", counselorId: userInfo._id, department: "心理学系", grade: "2023级" };
            return {class111, class112}; // 返回两个班级的信息对象
          });
        } else {
          // 如果 "112" 班级已存在，获取其数据
          class112 = res112.data[0];
          // 检查是否有关联的辅导员ID
          if (!class112.counselorId) {
            // 如果没有，则更新辅导员ID
            return db.collection('classes').doc(class112._id).update({
              data: {
                counselorId: userInfo._id,
                updateTime: db.serverDate()
              }
            }).then(() => {
              // 更新后重新获取最新数据
              return db.collection('classes').doc(class112._id).get();
            }).then(updatedClass => {
              class112 = updatedClass.data; // 更新class112变量
              return {class111, class112}; // 返回两个班级的信息对象
            });
          }
          // 如果已有辅导员ID，直接返回两个班级的信息对象
          return {class111, class112};
        }
      });
    }).then((classes) => {
      // classes 对象包含 class111 和 class112 的信息
      // 第三步：如果当前用户是辅导员 (teacher角色)，则更新其管理的班级列表
      const currentUserInfo = wx.getStorageSync('userInfo'); // 重新获取一次，确保最新
      if (currentUserInfo && currentUserInfo.role === 'teacher') {
        // 更新 'users' 集合中该辅导员的文档
        return db.collection('users').doc(currentUserInfo._id).update({
          data: {
            // 将两个班级的名称存入 classes 数组 (也可以存ID，取决于业务需求)
            classes: [classes.class111.name, classes.class112.name],
            updateTime: db.serverDate()
          }
        }).then(() => {
          return classes; // 继续传递班级信息，供下一步使用
        });
      }
      return classes; // 如果不是辅导员，直接传递班级信息
    }).then((classes) => {
      // 第四步：更新本地存储的辅导员用户信息
      const currentUserInfo = wx.getStorageSync('userInfo');
      if (currentUserInfo && currentUserInfo.role === 'teacher') {
        // 将新的班级列表 (名称) 更新到本地存储的userInfo中
        currentUserInfo.classes = [classes.class111.name, classes.class112.name];
        // 如果存在旧的 'class' 字段，则移除 (数据迁移)
        if (currentUserInfo.hasOwnProperty('class')) {
          delete currentUserInfo.class;
        }
        // 将更新后的userInfo存回本地存储
        wx.setStorageSync('userInfo', currentUserInfo);
      }
      
      return classes; // 继续传递班级信息
    }).then((classes) => {
      // 第五步：初始化这两个班级的学生数据
      // 调用initStudents函数，并传入两个班级的详细信息
      return this.initStudents(classes.class111, classes.class112);
    }).then(() => {
      // 所有初始化步骤成功完成后，隐藏加载提示并显示成功信息
      wx.hideLoading();
      wx.showToast({
        title: '初始化成功',
        icon: 'success'
      });
    }).catch(err => {
      // 如果任何步骤出现错误，则捕获错误
      console.error('初始化班级数据失败:', err);
      wx.hideLoading(); // 隐藏加载提示
      // 显示失败信息
      wx.showToast({
        title: '初始化失败',
        icon: 'none'
      });
    });
  },
  
  // 初始化学生数据函数，接收两个班级对象作为参数
  initStudents: function(class111, class112) {
    // 获取数据库实例
    const db = wx.cloud.database();
    // 打印传入的班级信息，用于调试
    console.log('正在初始化学生数据，班级1:', class111, '班级2:', class112);
    
    // 首先处理班级 "111" 的学生数据
    // 检查 'users' 集合中是否已存在属于 class111._id 且角色为 'student' 的学生
    return db.collection('users').where({
      classes: db.command.all([class111._id]), // 查询条件：classes数组包含class111._id
      role: 'student'                         // 且角色为student
    }).count().then(res => { // 获取满足条件的学生数量
      // 如果已存在学生数据，则不再重复添加
      if (res.total > 0) {
        console.log('111班级已有学生数据:', res.total);
        return Promise.resolve(); // 直接返回一个成功的Promise
      }
      
      // 如果没有学生数据，则为 "111" 班级添加5个测试学生
      const studentsPromises = []; // 用于存储所有添加学生操作的Promise
      const students = [
        { name: '张三', studentId: '2023001', phone: '13800000001', dormitory: 'A1-101' },
        { name: '李四', studentId: '2023002', phone: '13800000002', dormitory: 'A1-102' },
        { name: '王五', studentId: '2023003', phone: '13800000003', dormitory: 'A1-103' },
        { name: '赵六', studentId: '2023004', phone: '13800000004', dormitory: 'A1-201' },
        { name: '钱七', studentId: '2023005', phone: '13800000005', dormitory: 'A1-202' }
      ];
      
      // 遍历学生数组，为每个学生创建一个数据库添加操作
      students.forEach(student => {
        studentsPromises.push(
          db.collection('users').add({
            data: {
              ...student,                 // 学生的基本信息 (姓名, 学号等)
              classes: [class111._id],    // 将班级ID (class111._id) 存入classes数组
              role: 'student',            // 设置角色为 'student'
              createTime: db.serverDate(),// 创建时间
              updateTime: db.serverDate() // 更新时间
            }
          })
        );
      });
      
      // 等待所有为 "111" 班级添加学生的操作完成
      return Promise.all(studentsPromises);
    }).then(() => {
      // 然后处理班级 "112" 的学生数据
      // 检查 'users' 集合中是否已存在属于 class112._id 且角色为 'student' 的学生
      return db.collection('users').where({
        classes: db.command.all([class112._id]), // 查询条件：classes数组包含class112._id
        role: 'student'                         // 且角色为student
      }).count(); // 获取满足条件的学生数量
    }).then(res => {
      // 如果已存在学生数据，则不再重复添加
      if (res.total > 0) {
        console.log('112班级已有学生数据:', res.total);
        return Promise.resolve(); // 直接返回一个成功的Promise
      }
      
      // 如果没有学生数据，则为 "112" 班级添加3个测试学生
      const studentsPromises = [];
      const students = [
        { name: '陈一', studentId: '2023101', phone: '13900000001', dormitory: 'B1-101' },
        { name: '杨二', studentId: '2023102', phone: '13900000002', dormitory: 'B1-102' },
        { name: '刘三', studentId: '2023103', phone: '13900000003', dormitory: 'B1-103' }
      ];
      
      // 遍历学生数组，为每个学生创建一个数据库添加操作
      students.forEach(student => {
        studentsPromises.push(
          db.collection('users').add({
            data: {
              ...student,
              classes: [class112._id], // 将班级ID (class112._id) 存入classes数组
              role: 'student',
              createTime: db.serverDate(),
              updateTime: db.serverDate()
            }
          })
        );
      });
      
      // 等待所有为 "112" 班级添加学生的操作完成
      return Promise.all(studentsPromises);
    });
  },
  
  // 处理导航到"测试配置"页面的逻辑
  handleTestConfigNavigation: function() {
    console.log('===== 处理测试配置页面导航 =====');
    // 从本地存储中获取之前存入的 'currentTestConfigType' (当前要配置的测试类型)
    const testType = wx.getStorageSync('currentTestConfigType');
    console.log('从存储中获取的测试类型:', testType);
    
    // 如果没有获取到测试类型参数，则提示错误并返回
    if (!testType) {
      console.warn('未找到测试类型参数');
      wx.showToast({
        title: '参数错误',
        icon: 'none'
      });
      return;
    }
    
    // 再次检查用户权限，确保只有 'staff' (心理咨询师) 角色的用户可以进行测试配置
    const userInfo = wx.getStorageSync('userInfo');
    if (!userInfo || userInfo.role !== 'staff') {
      console.warn('用户无权执行此操作');
      wx.showToast({
        title: '您无权执行此操作',
        icon: 'none'
      });
      return;
    }
    
    // 准备直接导航到心理测试页面，并带上配置相关的参数
    console.log('准备直接跳转到测试配置页面');
    // isConfig=true 表示进入配置模式，type 参数传递测试类型
    const url = `/pages/psychological-test/index?isConfig=true&type=${testType}`;
    console.log('导航URL:', url);
    
    // 执行微信小程序页面导航操作
    wx.navigateTo({
      url: url,
      // 导航成功回调
      success: function() {
        console.log('成功导航到psychological-test/index页面进行配置');
      },
      // 导航失败回调
      fail: function(error) {
        console.error('导航到psychological-test/index配置失败:', error);
        wx.showToast({
          title: '页面导航失败',
          icon: 'none'
        });
        
        // 作为备用方案，如果主导航路径失败，尝试导航到另一个具体的配置页面路径
        console.log('尝试直接导航到备用配置页面路径');
        wx.navigateTo({
          url: `/pages/staff/test-management/test-config/index?type=${testType}`,
          success: function() {
            console.log('直接导航到备用配置页面成功');
          },
          fail: function(err) {
            // 如果备用方案也失败，则提示用户无法访问
            console.error('直接导航到备用配置页面也失败:', err);
            wx.showToast({
              title: '无法访问配置页面',
              icon: 'none'
            });
          }
        });
      }
    });
  },
}); 